package jp.co.piratealliance.pirateAllianceWeb.common.util;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

import jp.co.piratealliance.pirateAllianceWeb.common.exception.SystemException;

import com.sun.org.apache.regexp.internal.RE;

/**
 * copyright    Founder 2012
 * @date        2012/06/18 V1.0新規作成
 *
 * @author      xuwei
 * @version     V1.0
 * @brief       String変換処理Utilityクラスの定義.
 *
 * @since       1.0
 * @todo        なし
 */
public class StringUtils {
	/** TEL */
	private static final String TEL = "tel";

	/** ZIP */
	private static final String ZIP = "zip";

	/** エンコードの形式 */
	private static final String ENCODE = "Shift_JIS";

	private static String SUB_LINE = "_";

	/** 半角記号 - */
	public static String halfKgou = "!@#$&-_+/[\\]., ";

	/**
	 * The empty String {@code ""}.
	 * @since 2.0
	 */
	public static final String EMPTY = "";

	/**
	 * Represents a failed index search.
	 * @since 2.1
	 */
	public static final int INDEX_NOT_FOUND = -1;

	/**
	 * <p>The maximum size to which the padding constant(s) can expand.</p>
	 */
	private static final int PAD_LIMIT = 8192;

	/**
	 * A regex pattern for recognizing blocks of whitespace characters.
	 */
	private static final Pattern WHITESPACE_BLOCK = Pattern.compile("\\s+");

	/** 格式化の文字列定数 */
	private static final String FORMAT_TEXT = "#,###.#################################";

	/**
	 * 二つStringオブジェクトの内容を比べる
	 *
	 * @param s1
	 *            文字列１
	 * @param s2
	 *            文字列２
	 * @return 二つの文字列の内容は相同の場合、trueを返し、他のはfalseを返す 2003/11/07 新規作成 zhanjc
	 */
	public static boolean isEqual(String s1, String s2) {
		if (s1 == null) {
			s1 = "";
		}
		if (s2 == null) {
			s2 = "";
		}

		return (s1.equals(s2));
	}

	/**
	 * if a CharSequence is null.return  empty ("")
	 * @param input  the CharSequence
	 * @return
	 */
	public static String nvl(String input) {
		if (input == null) {
			return "";
		}

		return input;
	}

	/**
	 * Checks if a CharSequence is empty ("") or null.
	 * StringUtils.isEmpty(null)      = true
	 * StringUtils.isEmpty("")        = true
	 * StringUtils.isEmpty(" ")       = false
	 * StringUtils.isEmpty("bob")     = false
	 * StringUtils.isEmpty("  bob  ") = false
	 * @param cs the CharSequence to check, may be null
	 * @return if the CharSequence is empty or null
	 */
//	public static boolean isEmpty(CharSequence cs) {
//		return cs == null || cs.length() == 0;
//	}

	public static boolean isEmpty(String cs) {
		return cs == null || cs.length() == 0;
	}

	/**
	 * <p>Checks if a CharSequence is not empty ("") and not null.</p>
	 *
	 * <pre>
	 * StringUtils.isNotEmpty(null)      = false
	 * StringUtils.isNotEmpty("")        = false
	 * StringUtils.isNotEmpty(" ")       = true
	 * StringUtils.isNotEmpty("bob")     = true
	 * StringUtils.isNotEmpty("  bob  ") = true
	 * </pre>
	 *
	 * @param cs  the CharSequence to check, may be null
	 * @return if the CharSequence is not empty and not null
	 */
//	public static boolean isNotEmpty(CharSequence cs) {
//		return !StringUtils.isEmpty(cs);
//	}

	public static boolean isNotEmpty(String cs) {
		return !StringUtils.isEmpty(cs);
	}

	/**
	 * <p>Checks if a CharSequence is whitespace, empty ("") or null.</p>
	 *
	 * <pre>
	 * StringUtils.isBlank(null)      = true
	 * StringUtils.isBlank("")        = true
	 * StringUtils.isBlank(" ")       = true
	 * StringUtils.isBlank("bob")     = false
	 * StringUtils.isBlank("  bob  ") = false
	 * </pre>
	 *
	 * @param cs  the CharSequence to check, may be null
	 * @return if the CharSequence is null, empty or whitespace
	 */
	public static boolean isBlank(CharSequence cs) {
		int strLen;
		if (cs == null || (strLen = cs.length()) == 0) {
			return true;
		}
		for (int i = 0; i < strLen; i++) {
			if (Character.isWhitespace(cs.charAt(i)) == false) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <p>Checks if a CharSequence is not empty (""), not null and not whitespace only.</p>
	 *
	 * <pre>
	 * StringUtils.isNotBlank(null)      = false
	 * StringUtils.isNotBlank("")        = false
	 * StringUtils.isNotBlank(" ")       = false
	 * StringUtils.isNotBlank("bob")     = true
	 * StringUtils.isNotBlank("  bob  ") = true
	 * </pre>
	 *
	 * @param cs  the CharSequence to check, may be null
	 * @return if the CharSequence is
	 *  not empty and not null and not whitespace
	 */
	public static boolean isNotBlank(CharSequence cs) {
		return !StringUtils.isBlank(cs);
	}

	// Replacing
	// -----------------------------------------------------------------------
	/**
	 * <p>Replaces a String with another String inside a larger String, once.</p>
	 *
	 * <pre>
	 * StringUtils.replaceOnce(null, *, *)        = null
	 * StringUtils.replaceOnce("", *, *)          = ""
	 * StringUtils.replaceOnce("any", null, *)    = "any"
	 * StringUtils.replaceOnce("any", *, null)    = "any"
	 * StringUtils.replaceOnce("any", "", *)      = "any"
	 * StringUtils.replaceOnce("aba", "a", null)  = "aba"
	 * StringUtils.replaceOnce("aba", "a", "")    = "ba"
	 * StringUtils.replaceOnce("aba", "a", "z")   = "zba"
	 * </pre>
	 *
	 * @see #replace(String text, String searchString, String replacement, int max)
	 * @param text  text to search and replace in, may be null
	 * @param searchString  the String to search for, may be null
	 * @param replacement  the String to replace with, may be null
	 * @return the text with any replacements processed,
	 */
	public static String replaceOnce(String text, String searchString, String replacement) {
		return replace(text, searchString, replacement, 1);
	}

	/**
	 * <p>Replaces all occurrences of a String within another String.</p>
	 *
	 * <pre>
	 * StringUtils.replace(null, *, *)        = null
	 * StringUtils.replace("", *, *)          = ""
	 * StringUtils.replace("any", null, *)    = "any"
	 * StringUtils.replace("any", *, null)    = "any"
	 * StringUtils.replace("any", "", *)      = "any"
	 * StringUtils.replace("aba", "a", null)  = "aba"
	 * StringUtils.replace("aba", "a", "")    = "b"
	 * StringUtils.replace("aba", "a", "z")   = "zbz"
	 * </pre>
	 *
	 * @see #replace(String text, String searchString, String replacement, int max)
	 * @param text  text to search and replace in, may be null
	 * @param searchString  the String to search for, may be null
	 * @param replacement  the String to replace it with, may be null
	 * @return the text with any replacements processed,
	 */
	public static String replace(String text, String searchString, String replacement) {
		return replace(text, searchString, replacement, -1);
	}

	/**
	 * <p>Replaces a String with another String inside a larger String,
	 * for the first {@code max} values of the search String.</p>
	 *
	 * <pre>
	 * StringUtils.replace(null, *, *, *)         = null
	 * StringUtils.replace("", *, *, *)           = ""
	 * StringUtils.replace("any", null, *, *)     = "any"
	 * StringUtils.replace("any", *, null, *)     = "any"
	 * StringUtils.replace("any", "", *, *)       = "any"
	 * StringUtils.replace("any", *, *, 0)        = "any"
	 * StringUtils.replace("abaa", "a", null, -1) = "abaa"
	 * StringUtils.replace("abaa", "a", "", -1)   = "b"
	 * StringUtils.replace("abaa", "a", "z", 0)   = "abaa"
	 * StringUtils.replace("abaa", "a", "z", 1)   = "zbaa"
	 * StringUtils.replace("abaa", "a", "z", 2)   = "zbza"
	 * StringUtils.replace("abaa", "a", "z", -1)  = "zbzz"
	 * </pre>
	 *
	 * @param text  text to search and replace in, may be null
	 * @param searchString  the String to search for, may be null
	 * @param replacement  the String to replace it with, may be null
	 * @param max  maximum number of values to replace, or {@code -1} if no maximum
	 * @return the text with any replacements processed,
	 */
	public static String replace(String text, String searchString, String replacement, int max) {
		if (isEmpty(text) || isEmpty(searchString) || replacement == null || max == 0) {
			return text;
		}
		int start = 0;
		int end = text.indexOf(searchString, start);
		if (end == INDEX_NOT_FOUND) {
			return text;
		}
		int replLength = searchString.length();
		int increase = replacement.length() - replLength;
		increase = increase < 0 ? 0 : increase;
		increase *= max < 0 ? 16 : max > 64 ? 64 : max;
		StringBuilder buf = new StringBuilder(text.length() + increase);
		while (end != INDEX_NOT_FOUND) {
			buf.append(text.substring(start, end)).append(replacement);
			start = end + replLength;
			if (--max == 0) {
				break;
			}
			end = text.indexOf(searchString, start);
		}
		buf.append(text.substring(start));
		return buf.toString();
	}

	/**
	 * 前ゼロを付加した結果を返する
	 *
	 * @param val
	 *            ゼロフォーマット値
	 * @param length
	 *            変換したintからゼロフォーマット用文字数を生成する
	 * @return String 前ゼロを付加した文字列
	 */
	public static String addPreZero(Object val, int length) {
		if (val == null) {
			val = "";
		}
		String result = val.toString();
		int strLen = result.length();
		if (strLen < length) {
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < length - strLen; i++) {
				sb.append('0');
			}
			sb.append(val);
			result = sb.toString();
		} else {
			result = result.substring(0, length);
		}

		return result;
	}

	/**
	 * <pre>
	 * toString
	 *
	 * </pre>
	 * @param object
	 * @return
	 */
	public static String toString(Integer object) {
		if (object == null) {
			return "";
		} else {
			return object.toString();
		}
	}

	/**
	 * <pre>
	 * toString
	 *
	 * </pre>
	 * @param object
	 * @return
	 */
	public static String toString(Long object) {
		if (object == null) {
			return "";
		} else {
			return object.toString();
		}
	}

	/**
	 * <pre>
	 * toString
	 *
	 * </pre>
	 * @param object
	 * @return
	 */
	public static String toString(Date object) {
		if (object == null) {
			return "";
		} else {
			return object.toString();
		}
	}

	/**
	 * <pre>
	 * toString
	 *
	 * </pre>
	 * @param object
	 * @return
	 */
	public static String toString(BigDecimal object) {
		if (object == null) {
			return "";
		} else {
			return object.toString();
		}
	}

	/**
	 * 左、右スペス(半角と全角)を削除する
	 *
	 * @param val
	 *            String 変換文字列
	 * @return String 変換した文字列
	 */
	public static String trimSpc(String val) {
		if (val == null) {
			return "";
		} else {
			val = val.trim();
		}
		// 左スペス(半角と全角)数の変数
		int iHead = 0;
		// 左スペス(半角と全角)数を計算する
		for (int i = 0; i < val.length(); i++) {
			if (val.charAt(i) == ' ' || val.charAt(i) == '　') {
				iHead++;
			} else {
				break;
			}
		}
		// 右スペス(半角と全角)を削除した文字列を返す
		String valUse = val.substring(iHead);
		if (null != valUse) {
			int iEnd = valUse.length();
			for (int i = valUse.length() - 1; i >= 0; i--) {
				if (valUse.charAt(i) == ' ' || valUse.charAt(i) == '　') {
					iEnd--;
				} else {
					break;
				}
			}
			valUse = valUse.substring(0, iEnd);
		}
		return valUse;
	}

	/**
	 * コーマ区切りで、文字列から文字列を抜き出し、配列にして返す
	 *
	 * @param str
	 *            文字列
	 * @return String[] 変換後文字列アレー
	 */
	public static String[] str2Array(String str) {
		return str2Array(str, ",");
	}

	/**
	 * 文字列から文字列を抜き出し、配列にして返す
	 *
	 * @param str
	 *            文字列
	 * @param sep
	 *            区切り文字(群)
	 * @return String[] 変換後文字列 2003/11/06 新規作成 zhanjc
	 */
	public static String[] str2Array(String str, String sep) {
		StringTokenizer token = null;
		String[] array = null;

		// check
		if (str == null || sep == null) {
			return null;
		}

		// get string array
		token = new StringTokenizer(str, sep);
		array = new String[token.countTokens()];
		for (int i = 0; token.hasMoreTokens(); i++) {
			array[i] = token.nextToken();
		}

		return array;
	}

	/**
	 * 文字配列から文字列を抽出して組合し、文字列にして返す
	 *
	 * @param str
	 *            文字列
	 * @return String 変換後文字列
	 */
	public static String array2String(String[] str) {
		int num = 0;
		StringBuffer result = new StringBuffer("");

		// check
		if (str == null) {
			return "";
		}

		// 文字列を組合
		num = str.length;
		for (int i = 0; i < num; i++) {
			if (str[i] != null) {
				result.append(str[i]);
			}
		}

		return result.toString();
	}

	   /**
     * 文字配列から文字列を抽出して組合し、文字列にして返す
     *
     * @param str
     *            文字列
     * @param sep
     *            区切り文字
     * @return String 変換後文字列
     */
    public static String array2String(String[] str, String sep) {
        int num = 0;
        StringBuffer result = new StringBuffer("");

        // check
        if (str == null) {
            return "";
        }

        // 文字列を組合
        num = str.length;
        for (int i = 0; i < num; i++) {
            if (str[i] != null) {
                result.append(sep);
                result.append(str[i]);
            }
        }

        String resultStr = result.toString();
        if(resultStr.length() > 0)
        {
            resultStr = resultStr.substring(1);
        }
        return resultStr;
    }

	/**
	 * 正規表現チェックを行う。<br>
	 * 指定されたフィールドの入力値に対して、指定の正規表現フォーマットチェックを行う<br>
	 *
	 * @param value
	 *            入力フォーム
	 * @param regexp
	 *            正規表現フォーマット
	 * @return boolean チェックの結果
	 */
	public static boolean matches(String value, String regexp) {
		String paren = null;
		RE re = null;

		if (regexp == null || value == null) {
			return false;
		}
		re = new RE(regexp);
		if (!re.match(value)) {
			return false;
		}
		paren = re.getParen(0);
		if (!paren.equals(value)) {
			return false;
		}

		return true;
	}

	/**
	 * 正規表現チェックを行う。<br>
	 * 指定されたフィールドの入力値に対して、指定の正規表現フォーマットチェックを行う
	 *
	 * @param value
	 *            入力フォーム
	 * @param regexp
	 *            正規表現フォーマット
	 * @return String チェックの結果
	 */
	public static String matcheParen(String value, String regexp) {
		RE re = null;

		if (regexp == null || value == null) {
			return "";
		}
		re = new RE(regexp);
		if (!re.match(value)) {
			return "";
		}

		return re.getParen(0);
	}

	/**
	 * 文字列が全角のみのチェック
	 *
	 * @param txt
	 *            チェックしたいの文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isFull(String txt) {
		if (txt == null) {
			return true;
		}
		byte[] bytes = null;
		try {
			bytes = txt.getBytes("MS932");
		} catch (UnsupportedEncodingException uee) {
			// should no happen
			throw new IllegalStateException(uee);
		}
		int beams = txt.length() * 2;

		for (int i = 0; i < txt.length(); i++) {
			if ('\n' == txt.charAt(i)) {
				beams = beams - 2;
			}
		}

		return beams == bytes.length;
	}

	/**
	 * 文字列が半角数字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         <br>
	 */
	public static boolean isHalfNum(String txt) {
		if (txt == null) {
			return true;
		}
		if (matches(txt, "([0-9]+)")) {
			return true;
		}
		return false;
	}

	/**
	 * 文字列が半角のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalf(String txt) {
		if (txt == null) {
			return true;
		}
		try {
			txt = txt.replaceAll("\\?", "");

			byte[] b = txt.getBytes(ENCODE);
			for (int i = 0; i < b.length; i++) {
				if ((b[i] & 0x80) == 0x80) {
					// 判定：b[i]は0xA0-0xDFの範囲に存在するか。この範囲は半角カナ文字のみ
					if (!(((byte) 0xA0) <= b[i] && b[i] <= ((byte) 0xDf))) {
						// 全角文字の１バイト目
						return false;
					}
				} else if (b[i] == 0x3F) {
					return false;
				}
			}
			return true;
		} catch (java.io.UnsupportedEncodingException e) {
			// logger.debug(e.getMessage());
			return false;
		}
	}

	/**
	 * 文字列が半角英数字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfENGNum(String txt) {
		StringBuffer checkText = null;

		if (txt == null) {
			return true;
		}
		checkText = new StringBuffer(txt);
		for (int i = 0; i < checkText.length(); i++) {
			String subcheckText = checkText.substring(i, i + 1);
			if (!matches(subcheckText, "([a-zA-Z]+)") && !matches(subcheckText, "([0-9]+)")) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 文字列が半角英数字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfENGNumExt1(String txt) {
		StringBuffer checkText = null;

		if (txt == null) {
			return true;
		}
		checkText = new StringBuffer(txt);
		for (int i = 0; i < checkText.length(); i++) {
			String subcheckText = checkText.substring(i, i + 1);
			if (!matches(subcheckText, "([a-zA-Z]+)") && !matches(subcheckText, "([0-9]+)")
					&& !StringUtils.isEqual(subcheckText, SUB_LINE)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 文字列が半角英数字記号のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfENGNumKgou(String txt) {
		StringBuffer checkText = null;

		if (txt == null) {
			return true;
		}
		checkText = new StringBuffer(txt);
		for (int i = 0; i < checkText.length(); i++) {
			String subcheckText = checkText.substring(i, i + 1);
			if (!matches(subcheckText, "([a-zA-Z]+)") && !matches(subcheckText, "([0-9]+)") && !isKgou(subcheckText)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 文字列が半角英数字記号カナのみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isEnNumKanaKgouHalf(String txt) {
		if (txt == null) {
			return true;
		}
		try {
			byte[] b = txt.getBytes(ENCODE);
			for (int i = 0; i < b.length; i++) {
				if (!(((byte) 0xA0) <= b[i] && b[i] <= ((byte) 0xDf) || (0x20 <= b[i] && b[i] <= 0x7E))) {
					return false;
				}
			}
			return true;
		} catch (java.io.UnsupportedEncodingException e) {
			// logger.debug(e.getMessage());
			return false;
		}
	}

	/**
	 * 文字列が半角記号のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isKgou(String txt) {
		if (txt == null) {
			return true;
		}

		// 判定：パラメーターは（!@#$&-_+/\. , 半角スペース）の範囲に存在であるか。この範囲は半角記号文字のである
		// !#$%&'()*+,-./:;<=>?@[\\]^_`{|}~
		if (halfKgou.indexOf(txt) != -1) {
			return true;
		}

		return false;
	}

	/**
	 * 文字列が半角記号のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isAllKgou(String txt) {
		if (txt == null) {
			return true;
		}
		StringBuffer checkText = null;
		boolean result = true;
		// 判定：パラメーターは（!@#$&-_+/\. , 半角スペース）の範囲に存在であるか。この範囲は半角記号文字のである
		// !#$%&'()*+,-./:;<=>?@[\\]^_`{|}~
		checkText = new StringBuffer(txt);
		for (int i = 0; i < checkText.length(); i++) {
			String subcheckText = checkText.substring(i, i + 1);
			if (!isKgou(subcheckText)) {
				result = false;
			}
		}

		return result;
	}

	/**
	 * 文字列が半角英小数字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfENGSmallNum(String txt) {
		StringBuffer checkText = null;

		if (txt == null) {
			return true;
		}
		checkText = new StringBuffer(txt);
		for (int i = 0; i < checkText.length(); i++) {
			String subcheckText = checkText.substring(i, i + 1);
			if (!matches(subcheckText, "([a-z]+)") && !matches(subcheckText, "([0-9]+)")) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 文字列が半角英大数字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfENGBigNum(String txt) {
		StringBuffer checkText = null;
		if (txt == null) {
			return true;
		}
		checkText = new StringBuffer(txt);
		for (int i = 0; i < checkText.length(); i++) {
			String subcheckText = checkText.substring(i, i + 1);
			if (!matches(subcheckText, "([A-Z]+)") && !matches(subcheckText, "([0-9]+)")) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 文字列が半角英字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfEN(String txt) {
		if (txt == null) {
			return true;
		}
		if (matches(txt, "([a-zA-Z]+)")) {
			return true;
		}
		return false;
	}

	/**
	 * 文字列が半角英小字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfSmallEN(String txt) {
		if (txt == null) {
			return true;
		}
		if (matches(txt, "([a-z]+)")) {
			return true;
		}
		return false;
	}

	/**
	 * 文字列が半角英大字のみかをチェックする
	 *
	 * @param txt
	 *            チェック文字列
	 * @return boolean 空文字列の場合は、trueを返し、<br>
	 *         文字列はShift_JISのエンコードに変換失敗の場合、falseを返す<br>
	 */
	public static boolean isHalfBigEN(String txt) {
		if (txt == null) {
			return true;
		}
		if (matches(txt, "([A-Z]+)")) {
			return true;
		}
		return false;
	}

	/**
	 * 正整数 valicate
	 * @param txt
	 * @return
	 */
	public static boolean isPositiveNumHalf(String txt) {
		if (isEmpty(txt)) {
			return true;
		}

		if (matches(txt, "([0-9]+)")) {
			if (Integer.parseInt(txt) <= 0) {
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/**
	 * 数字を-0 ----> 0のようなフォーマットで変換し、変換した文字列を返す
	 *
	 * @param number
	 *            変換する文字列
	 * @return String 変換した文字列
	 */
	private static String convertToValid(String number) {
		if (number.trim().equals("-0")) {
			return "0";
		} else {
			return number;
		}
	}

	/**
	 * 全部ゼロ又はnullの場合 空文字列にして返す
	 *
	 * @param val
	 *            変換する文字列
	 * @return 空文字列 valは全部ゼロ又はnull又は空文字列の場合 空文字列にして返す
	 */
	public static String filteZero(String val) {
		if (val == null || "".equals(val.trim())) {
			return "";
		}
		if (!NumberUtils.checkIntNumberValid(val)) {
			return "";
		}
		val = new Long(val.trim()).toString();

		return val;
	}

	/**
	 * 数字文字列を9999999.99 ----> 9,999,999.99のようなフォーマットに変換する
	 *
	 * @param number
	 *            数字の文字列
	 * @return String 変換後の文字列
	 */
	public static String formatNumber(String number) {
		// 整数処理のフラグはfalseに固定し、関数を呼び出す
		try {
			return formatNumber(number, false);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999のようなフォーマットに変換する
	 *
	 * @param number
	 *            数字の文字列
	 * @param formatToLong
	 *            書式の制御フラグ
	 * @return String 変換した文字列
	 */
	public static String formatNumber(String number, boolean formatToLong) {
		try {
			return formatNumber(number, formatToLong, false);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字文字列を9999999.99 ----> 9,999,999.99のようなフォーマットに変換する
	 *
	 * @param number
	 *            数字文字列
	 * @param formatToLong
	 *            小数を整数に変換する
	 * @param nullToZero
	 *            空白文字列がゼロに変換処理のフラグ：trueの場合、変換する、falseの場合、変換しない
	 * @return String 変換した文字列
	 */
	public static String formatNumber(String number, boolean formatToLong, boolean nullToZero) {
		// ゼロが空白文字列に変換処理のフラグはfalseに固定し、関数を呼び出す
		try {
			return formatNumber(number, formatToLong, nullToZero, false);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999.99のようなフォーマットに変換する
	 *
	 * @param number
	 *            数字の文字列
	 * @param formatToLong
	 *            小数を整数に変換する
	 * @param nullToZero
	 *            空白文字列がゼロに変換処理のフラグ：trueの場合、変換する、falseの場合、変換しない
	 * @param zeroToNull
	 *            ゼロが空白文字列に変換処理のフラグ：trueの場合、変換する、falseの場合、変換しない
	 * @return String 変換した文字列
	 */
	public static String formatNumber(String number, boolean formatToLong, boolean nullToZero, boolean zeroToNull) {
		if (number == null || number.trim().equals("")) {
			if (nullToZero) {
				return "0";
			} else {
				return "";
			}
		}
		// 数字の文字列が０または-0の場合、zeroToNullによって、""或いは"0"を返す
		if (number.trim().equals("0") || number.trim().equals("-0")) {
			if (zeroToNull) {
				return "";
			} else {
				return "0";
			}
		}
		// 数字値の検査関数を呼び出す
		if (!NumberUtils.checkNumberValid(number)) {
			return number.trim();
		}
		String sFormatNumber = "";
		double dbNum;
		// 数字の文字列を指定した形式で数値に変換する
		NumberFormat defForm = new DecimalFormat(FORMAT_TEXT);
		try {
			dbNum = Double.parseDouble(number);
			if (formatToLong) {
				dbNum = Math.round(dbNum);
			}
			sFormatNumber = defForm.format(dbNum); // 書式化
		} catch (NumberFormatException numEx) {
			try {
				// 99,9999,9 --> 99,999,999
				Number numNumber = NumberFormat.getNumberInstance().parse(number);
				dbNum = Double.parseDouble(String.valueOf(numNumber));
				if (formatToLong) {
					dbNum = Math.round(dbNum);
				}
				sFormatNumber = defForm.format(dbNum);
			} catch (ParseException pEx) {
				throw new SystemException(pEx);
			}
		}
		return convertToValid(sFormatNumber);
	}

	/**
	 * 数字を906 --> 906%のようなフォーマットに変換する
	 *
	 * @param number
	 *            文字列
	 * @return String 変換した文字列
	 */
	public static String formatPercentNumber(String number) {
		// ヌル又は空文字列の場合、""を返す
		if (number == null || number.trim().equals("")) {
			return "";
		}
		// 数字の文字列は0又は-0の場合、0を返す
		if (number.trim().equals("0") || number.trim().equals("-0")) {
			return "0";
			// 数字文字列の末に、%を追加して返す。
		} else if (NumberUtils.checkNumberValid(number)) {
			return number + "%";
		} else {
			return number.trim();
		}
	}

	/**
	 * 数字を90600 --> 90600.00のようなフォーマットに変換する
	 *
	 * @param number
	 *            文字列
	 * @return String 変換した文字列
	 */
	public static String formatDecimalNumber(String number,int decimalWidth) {
		String result = "";
		// ヌル又は空文字列の場合、""を返す
		if (number == null || number.trim().equals("")) {
			result =  "0";
			return result;
		}else
			result = number;

		String format = "#";
		if(decimalWidth==0){
			format = "#";
		}else if(decimalWidth==1){
			format = "0.0";
		}else if(decimalWidth==2){
			format = "0.00";
		}else if(decimalWidth==3){
			format = "0.000";
		}

		DecimalFormat rateformat = new DecimalFormat(format);
		return rateformat.format(new BigDecimal(result));

	}


	/**
	 * 数字を90600 --> 90600.00のようなフォーマットに変換する
	 * RoundingMode.DOWN
	 * @param number
	 *            文字列
	 * @return String 変換した文字列
	 */
	public static String formatDecimalNumberExp(String number,int decimalWidth) {
		String result = "";
		// ヌル又は空文字列の場合、""を返す
		if (number == null || number.trim().equals("")) {
			result =  "0";
			return result;
		}else
			result = number;

		String format = "#";
		if(decimalWidth==0){
			format = "#";
		}else if(decimalWidth==1){
			format = "0.0";
		}else if(decimalWidth==2){
			format = "0.00";
		}else if(decimalWidth==3){
			format = "0.000";
		}

		DecimalFormat rateformat = new DecimalFormat(format);

		rateformat.setRoundingMode(RoundingMode.DOWN);
		return rateformat.format(new BigDecimal(result));
	}
	/**
	 * 入力された文字列を｢9999999-9999｣のようなフォーマットに変換する
	 *
	 * @param phoneNumber
	 *            電話番号の文字列
	 * @return String phoneNumber 電話番号を035678-9999の形式に出力
	 */
	public static String formatPhoneNumber(String phoneNumber) {
		return formatPhoneNumber(phoneNumber, true);
	}

	/**
	 * 入力された文字列を｢9999999-9999｣又は「99999999999」のようなフォーマットに変換する
	 *
	 * @param phoneNumber
	 *            電話番号の文字列
	 * @param bAddHyphenSpace
	 *            ハイフンとスペースを追加するかどうかフラグ
	 * @return String phoneNumber 編集形式を出力する
	 */
	public static String formatPhoneNumber(String phoneNumber, boolean bAddHyphenSpace) {
		if (phoneNumber == null || phoneNumber.trim().equals("")) {
			return "";
		}
		phoneNumber = filtePhoneNumberZero(phoneNumber).trim();
		if (phoneNumber.equals("0")) {
			return "";
		}
		boolean bIsNumeric = matches(phoneNumber, "[0-9]+");
		StringBuffer temp = new StringBuffer(phoneNumber);
		int strLength = phoneNumber.getBytes().length;
		if (strLength < 11) {
			if (bIsNumeric && strLength == 9 && phoneNumber.charAt(0) != '0') {
				temp.insert(0, ' ');
				strLength++;
			}
			for (int i = 0; bAddHyphenSpace && i < 11 - strLength; i++) {
				temp.insert(0, ' ');
			}
		}
		if (strLength < 12 && bAddHyphenSpace) {
			if (bIsNumeric) {
				temp.insert(7, '-');
			} else {
				temp.insert(0, ' ');
			}
		}
		return temp.toString().trim();
	}

	/**
	 * 入力された文字列のプリゼロを削除し、全て０時一つ０しか保留しない
	 *
	 * @param phoneNumber
	 *            電話番号の文字列
	 * @return String phoneNumber 変換した形式を出力する
	 */
	public static String filtePhoneNumberZero(String phoneNumber) {
		if (phoneNumber == null) {
			return null;
		}
		String temp = phoneNumber.trim();
		int strLength = temp.length();
		boolean bIsNumeric = matches(temp, "[0-9]+");
		if (bIsNumeric) {
			for (int i = 0; i < strLength; i++) {
				if (temp.charAt(i) != '0') {
					if (i > 1) {
						phoneNumber = temp.substring(i - 1);
					}
					break;
				}
			}
		}
		return phoneNumber;
	}

	/**
	 * 数字をZZ.ZZ ----> Z9.999のようなフォーマットに変換する
	 *
	 * @param rate
	 *            数字の文字列
	 * @return String 変換した文字列
	 */
	public static String formatRate(String rate) {
		if (rate == null || "".equals(rate.trim())) {
			return "";
		}
		if (!NumberUtils.checkNumberValid(rate)) {
			return rate.trim();
		} else {
			DecimalFormat rateformat = new DecimalFormat("#,##0.000");
			try {
				double numericrate = Double.parseDouble(rate.trim()) + 0.0000000001;
				rate = rateformat.format(numericrate);
				if ("0.000".equals(rate)) {
					return " ";
				} else if (rate.substring(rate.length() - 3, rate.length()).equals("000")) {
					rate = rate.substring(0, rate.length() - 3) + "0";
				} else {
					while (rate.endsWith("0")) {
						rate = rate.substring(0, rate.length() - 1);
					}
				}
			} catch (Exception ex) {
				throw new SystemException(ex);
			}
		}
		if (rate != null && !"".equals(rate.trim())) {
			rate = rate + "%";
		}
		return rate;
	}

	/**
	 * 郵便番号をフォーマットに変換する。<br>
	 *
	 * @param postNum
	 *            入力フォーム
	 * @return String 変換後文字列
	 */
	public static String formatPostNum(String[] postNum) {
		if (postNum == null) {
			return "";
		}
		StringBuffer result = new StringBuffer();
		for (int i = 0; i < postNum.length; i++) {
			if (postNum[i] == null || postNum[i].trim().equals("")) {
				return "";
			}
			if (i != 0) {
				result.append("-");
			}
			result.append(postNum[i]);
		}
		return result.toString();
	}

	/**
	 * 郵便番号をフォーマットに変換する。<br>
	 *
	 * @param postNum
	 *            入力フォーム
	 * @return String 変換した文字列 2003/11/10 新規作成 zhanjc
	 */
	public static String formatPostNum(String postNum) {
		if (postNum == null || postNum.length() != 7) {
			return postNum;
		}
		return postNum.trim().substring(0, 3) + "-" + postNum.trim().substring(3, 7);
	}

	/**
	 * 郵便番号をフォーマットに変換する。<br>
	 *
	 * @param postNum
	 *            入力フォーム
	 * @return String 変換した文字列
	 */
	public static String[] formatPostNumToArray(String postNum) {
		String[] postNumArray = { "", "" };
		if (postNum == null || postNum.length() != 7) {
		} else {
			postNumArray[0] = postNum.trim().substring(0, 3);
			postNumArray[1] = postNum.trim().substring(3, 7);
		}
		return postNumArray;
	}

	/**
	 * 読点を削除します
	 *
	 * @param input
	 * @return
	 */
	public static String removeComma(String input) {
		if (StringUtils.isBlank(input)) {
			return input;
		} else {
			return input.replaceAll(",", "");
		}
	}

	public static String removePoint(String input) {
		if (StringUtils.isBlank(input)) {
			return input;
		} else {
			return input.replaceAll("\\.", "");
		}
	}

	public static String removeSlash(String input) {
		if (StringUtils.isBlank(input)) {
			return input;
		} else {
			return input.replaceAll("/", "");
		}
	}

	/**
	 * SQL分に使用されるため、List〈String〉から読点で分けた文字列に転換します。 e.g<br>
	 * List&lt;String&gt; list=new ArrayList&lt;String&gt();<br>
	 * list.add("first");<br>
	 * list.add("second");<br>
	 * Stirng str="'first','second'"<br>
	 *
	 * @param inputList
	 *            入力のList型
	 * @return String
	 */
	public static String listToSQLString(List<String> inputList) {
		StringBuffer output = new StringBuffer();
		for (int i = 0; i < inputList.size(); i++) {
			output.append("'");
			output.append(inputList.get(i));
			output.append("',");
		}

		if (output.length() > 0) {
			output.delete(output.length() - 1, output.length());
		}

		return output.toString();
	}

	/**
	 * SQL分に使用されるため、List〈String〉から読点で分けた文字列に転換します。 e.g<br>
	 * List&lt;String&gt; list=new ArrayList&lt;String&gt();<br>
	 * list.add("first");<br>
	 * list.add("second");<br>
	 * Stirng str="'first','second'"<br>
	 *
	 * @param inputList
	 *            入力のList型
	 * @return String
	 */
	public static String listToString(List<String> inputList) {
		StringBuffer output = new StringBuffer();
		for (int i = 0; i < inputList.size(); i++) {
			output.append(inputList.get(i));
			output.append(",");
		}
		if (output.length() > 0) {
			output.delete(output.length() - 1, output.length());
		}
		return output.toString();
	}

	/**
	 * Stringから読点で分けたListに転換します。 e.g<br>
	 * Stirng str="'first','second'"<br>
	 *
	 * @param str
	 *            入力のstring型
	 * @return List<String>
	 */
	public static List<String> stringToList(String str) {
		List<String> outputList = new ArrayList<String>();
		if (!"".equals(StringUtils.nvl(str))){
			if(str.trim().indexOf(",") > 0){
				String[] arry = str.trim().split(",");
				for(int i=0;i<arry.length;i++){
					outputList.add(arry[i]);
				}
			}else if(str.length() > 0){
				outputList.add(str);
			}
		}
		return outputList;
	}

	/**
	 * srcにsubStrを含むか
	 * @param src     文字列
	 * @param subStr　  検索文字列
	 * @return
	 */
	public static boolean isContains(String src, String subStr) {
		if (src != null && subStr != null && src.contains(subStr)) {
			return true;
		}
		return false;
	}

	/**
	 * 電話番号あるいは郵便番号の書式に変換する
	 *
	 * @param code
	 *            電話番号あるいは郵便番号の文字列
	 * @param type
	 *            電話番号あるいは郵便番号のタイプ識別
	 * @return String 変換した電話番号あるいは郵便番号
	 * @author zhanjc
	 */
	public static String addHyphen(String code, String type) {
		// パラメータのチェック
		if (code == null || type == null) {
			// パラメータエラー場合、空ろ文字列を返す
			return "";
		}
		code = code.trim();
		type = type.trim();
		if ("".equals(code) || "".equals(type)) {
			// パラメータエラー場合、空ろ文字列を返す
			return "";
		}

		if (TEL.equals(type)) {
			return formatPhoneNumber(code);
		} else if (ZIP.equals(type)) {
			if (code.length() != 7) {
				return code;
			} else {
				return code.substring(0, code.length() - 4) + "-" + code.substring(code.length() - 4);
			}
		} else {
			return code;
		}
	}

	/**
	 * 整数の前ゼロを削除した結果を返する
	 *
	 * @param number
	 *            longに変換後、この値をからゼロフォーマット用文字数を生成する
	 * @return String 前ゼロを削除した文字列
	 */
	public static String decreasePreZero(String number) {
		String result = number;
		// ヌル又は空文字列の場合、""を返す
		if (number == null) {
			return "";
		}
		number = number.trim();
		if ("".equals(number)) {
			return "";
		}
		if ("0".equals(number) || "-0".equals(number)) {
			return "0";
		}
		// 数字値の検査関数を呼び出す
		if (NumberUtils.checkNumberValid(number)) {
			// 数字を通貨のフォーマットに変換する
			long numNumber = 0;
			numNumber = Long.parseLong(number);
			result = String.valueOf(numNumber);
		}
		return result;
	}

	/**
	 * numberをtimesで割って、計算の結果を返す
	 *
	 * @param number
	 *            数字の文字列
	 * @param times
	 *            計算数
	 * @return double 変換後の文字列
	 */
	private static double devideTimes(String number, int times) {
		if (number == null) {
			return 0D;
		}
		String sign = "";
		if (number.charAt(0) == '-') {
			sign = "-";
			number = number.substring(1);
		}
		int oldDotPosition = number.indexOf(".");
		if (oldDotPosition == -1) {
			number = number + ".";
			oldDotPosition = number.indexOf(".");
		}
		if (oldDotPosition == 0) {
			number = "0" + number;
			oldDotPosition = number.indexOf(".");
		}

		int moveSteps = String.valueOf(times).length();
		int newDotPosition;
		if (oldDotPosition >= moveSteps) {
			newDotPosition = oldDotPosition - moveSteps + 1;
		} else {
			int zeroCount = moveSteps - oldDotPosition;
			for (int i = 0; i < zeroCount; i++) {
				number = "0" + number;
			}
			newDotPosition = 1;
			oldDotPosition = number.indexOf(".");
		}
		String prefix = number.substring(0, newDotPosition);
		String suffix = number.substring(newDotPosition, oldDotPosition);
		if (oldDotPosition < number.length()) {
			suffix = suffix + number.substring(oldDotPosition + 1);
		}
		return Double.parseDouble(sign + prefix + "." + suffix);
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999.99円のようなフォーマットに変換する
	 *
	 * @param number
	 *            数字の文字列
	 * @return String 変換した文字列
	 */
	public static String formatCurrency(String number) {
		// 円
		try {
			return formatCurrency(number, 3, false, true, false, false);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999.99円のようなフォーマットに変換する
	 *
	 * @param number
	 *            数字の文字列
	 * @param zeroToNull
	 *            ゼロ変換の制御フラグ：trueの場合、０は空文字列に変換する。falseの場合、変換しない
	 * @return String 変換した文字列
	 */
	public static String formatCurrency(String number, boolean zeroToNull) {
		// 円
		try {
			return formatCurrency(number, 3, false, true, false, zeroToNull);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999.99千円、あるいは9999999.99 ----> 9,999,999.99万円 のようなフォーマットに変換し、結果の文字列を返す
	 *
	 * @param number
	 *            文字列
	 * @param suffix
	 *            接尾辞のフラグ：1は千円、その他は万円
	 * @param needProcess
	 *            変換処理制御のフラグ：true 1.千円 9999999.99 ----> 9,999.99千円 2.万円 9999999.99 ----> 999.99万円 その他 円 9999999.99 ----> 9,999,999.99(円) false 1.千円 9999999.99 ----> 9,999,999.99千円 2.万円 9999999.99
	 *            ----> 9,999,999.99万円 その他 円 9999999.99 ----> 9,999,999.99(円)
	 * @return String 変換した文字列
	 */
	public static String formatCurrency(String number, int suffix, boolean needProcess) {
		// 千円,万円
		try {
			return formatCurrency(number, suffix, needProcess, true, false);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999.99(千円)、あるいは9999999.99 ----> 9,999,999.99(万円) のようなフォーマットに変換し、結果の文字列を返す
	 *
	 * @param number
	 *            数字の文字列
	 * @param suffix
	 *            接尾辞のフラグ：1は千円、その他は万円
	 * @param needProcess
	 *            変換処理制御のフラグ： true 1.千円 9999999.99 ----> 9,999.99(千円) 2.万円 9999999.99 ----> 999.99(万円) その他 円 9999999.99 ----> 9,999,999.99(円) false 1.千円 9999999.99 ----> 9,999,999.99(千円) 2.万円
	 *            9999999.99 ----> 9,999,999.99(万円) その他 円 9999999.99 ----> 9,999,999.99(円)
	 * @param hasSuffix
	 *            接尾辞の制御フラグ：trueは有り、falseはない
	 * @param formatToLong
	 *            格式化の制御フラグ： true 9999999.99 ----> 10,000,000 false 9999999.99 ----> 9,999,999.99
	 * @return String 変換した文字列
	 */
	public static String formatCurrency(String number, int suffix, boolean needProcess, boolean hasSuffix,
			boolean formatToLong) {
		try {
			return formatCurrency(number, suffix, needProcess, hasSuffix, formatToLong, false);
		} catch (Exception e) {
			throw new SystemException(e);
		}
	}

	/**
	 * 数字を9999999.99 ----> 9,999,999.99(千円)、あるいは9999999.99 ----> 9,999,999.99(万円) のようなフォーマットに変換し、結果の文字列を返す
	 *
	 * @param number
	 *            変換する文字列 0 --> "" || 0
	 * @param suffix
	 *            接尾辞のフラグ：1は千円、その他は万円
	 * @param needProcess
	 *            処理の制御フラグ： true 1.千円 9999999.99 ----> 9,999.99(千円) 2.万円 9999999.99 ----> 999.99(万円) その他 円 9999999.99 ----> 9999999.99(円) false 1.千円 9999999.99 ----> 9,999,999.99(千円) 2.万円 9999999.99
	 *            ----> 9,999,999.99(万円) その他 円 9999999.99 ----> 9999999.99(円)
	 * @param hasSuffix
	 *            接尾辞の制御フラグ：trueは有り、falseは無し
	 * @param formatToLong
	 *            格式化の制御フラグ： true 9999999.99 ----> 10,000,000 false 9999999.99 ----> 9,999,999.99
	 * @param zeroToNull
	 *            ゼロ変換の制御フラグ：trueの場合、０は空文字列に変換する。 falseの場合、変換しない
	 * @return String 変換後の文字列
	 */
	public static String formatCurrency(String number, int suffix, boolean needProcess, boolean hasSuffix,
			boolean formatToLong, boolean zeroToNull) {
		// ヌル又は空文字列の場合、""を返す
		if (number == null || number.trim().equals("")) {
			return "";
		}
		if (number.trim().equals("0") || number.trim().equals("-0")) {
			if (zeroToNull) {
				return "";
			}
		}
		// 数字値の検査関数を呼び出す
		if (!NumberUtils.checkNumberValid(number)) {
			return number.trim();
		}
		String currencySuffix = "";
		String currency = "";
		int times;
		// suffixによって、"千円"又は"万円"を追加する
		if (suffix == 1) {
			if (hasSuffix) {
				currencySuffix = "千円";
			}
			times = 1000;
		} else if (suffix == 2) {
			if (hasSuffix) {
				currencySuffix = "万円";
			}
			times = 10000;
		} else {
			if (hasSuffix) {
				currencySuffix = "円";
			}
			times = 1;
		}
		// formatToLongのように
		double num;
		NumberFormat defForm = new DecimalFormat(FORMAT_TEXT);
		if (needProcess) {
			try {
				// numberをtimesで割って、計算結果を返す
				num = devideTimes(number, times);// throw
				// NumberFormatException
				if (formatToLong) {
					num = Math.round(num);
				}
				currency = defForm.format(num);
			} catch (NumberFormatException numEx) {
				try {
					// 数字を通貨のフォーマットに変換する
					Number numNumber = NumberFormat.getNumberInstance().parse(number);
					num = devideTimes(String.valueOf(numNumber), times);
					if (formatToLong) {
						num = Math.round(num);
					}
					currency = defForm.format(num);
				} catch (ParseException pEx) {
					throw new SystemException(pEx);
				}
			}
		} else {
			try {
				currency = formatNumber(number, formatToLong);
			} catch (Exception e) {
				throw new SystemException(e);
			}
		}

		return convertToValid(currency) + currencySuffix;
	}

	/**
	 * <pre>
	 * 文字列の数値＋１を返す
	 *
	 * </pre>
	 * @param input
	 * @return input + 1の文字列
	 */
	public static String plusOne(String input) {
		return StringUtils.addPreZero(NumberUtils.convertToInteger(input) + 1, input.length());
	}

	/**
	 * <pre>
	 * 挿入ソート
	 *           パラメータがIntegerのリスト
	 * </pre>
	 * @param oldList Integerのリスト
	 * @param sortFlg  true:昇順  false:降順
	 * @return ソート後リスト
	 */
	public static List<String> sortList(List<String> oldList,boolean sortFlg) {
		List<String> tlist = new ArrayList<String>();
		for (int i = 0; i < oldList.size(); i++) {
			if (tlist.size() == 0) {
				tlist.add(oldList.get(0));
			} else {
				boolean b = false;
				for (int j = 0; j < tlist.size(); j++) {
					if ((sortFlg && Integer.parseInt(oldList.get(i)) >= Integer.parseInt(tlist.get(j)))
							|| (!sortFlg && Integer.parseInt(oldList.get(i)) < Integer.parseInt(tlist.get(j)))) {
						b = true;
					} else {
						tlist.add(j, oldList.get(i));
						b = false;
						break;
					}
				}
				if (b) {
					tlist.add(oldList.get(i));
				}
			}
		}
		return tlist;
	}


	/**
	 * JAVAのBlank文字をHTML表示文字に変換する
	 * @param inputStr
	 * @return
	 */
	public static String escapeBlankStr(String inputStr){
		if(inputStr==null)
			return null;
		return inputStr.replaceAll(" ", "&nbsp;&nbsp;");
	}

	/**
	 * @param input
	 *
	 * @return String.
	 */
	public static String ToSBC(String input) {
		if(input==null)
			return input;
		char c[] = input.toCharArray();
		for (int i = 0; i < c.length; i++) {
			if (c[i] == ' ') {
				c[i] = '\u3000';
			} else if (c[i] < '\177') {
				c[i] = (char) (c[i] + 65248);

			}
		}
		return new String(c);
	}

	/**
	 * 全角アルファベットを半角アルファベットに変換する
	 * @param s
	 * @return
	 */
	  public static String zenkakuAlphabetToHankaku(String s) {
			if(s==null)
				return null;
		    StringBuffer sb = new StringBuffer(s);
		    for (int i = 0; i < sb.length(); i++) {
		      char c = sb.charAt(i);
		      if (c >= 'ａ' && c <= 'ｚ') {
		        sb.setCharAt(i, (char) (c - 'ａ' + 'a'));
		      } else if (c >= 'Ａ' && c <= 'Ｚ') {
		        sb.setCharAt(i, (char) (c - 'Ａ' + 'A'));
		      }
		    }
		    return sb.toString();
		  }

		/**
		 * 半角アルファベットを全角アルファベットに変換する
		 * @param s
		 * @return
		 */
	  public static String hankakuAlphabetToZenkakuAlphabet(String s) {
			if(s==null)
				return null;
		    StringBuffer sb = new StringBuffer(s);
		    for (int i = 0; i < s.length(); i++) {
		      char c = s.charAt(i);
		      if (c >= 'a' && c <= 'z') {
		        sb.setCharAt(i, (char)(c - 'a' + 'ａ'));
		      } else if (c >= 'A' && c <= 'Z') {
		        sb.setCharAt(i, (char)(c - 'A' + 'Ａ'));
		      }
		    }
		    return sb.toString();
	  }
		/**
		 * 全角数字を半角数字に変換する
		 * @param s
		 * @return
		 */
	  public static String hankakuNumberToZenkakuNumber(String s) {
			if(s==null)
				return null;
		    StringBuffer sb = new StringBuffer(s);
		    for (int i = 0; i < s.length(); i++) {
		      char c = s.charAt(i);
		      if (c >= '0' && c <= '9') {
		        sb.setCharAt(i, (char) (c - '0' + '０'));
		      }
		    }
		    return sb.toString();
		  }

	  /**
	   * 全角数字を半角に変換します。
	   * @param s 変換元文字列
	   * @return 変換後文字列
	   */
	  public static String zenkakuNumToHankaku(String s) {
			if(s==null)
				return null;
	    StringBuffer sb = new StringBuffer(s);
	    for (int i = 0; i < sb.length(); i++) {
	      char c = sb.charAt(i);
	      if (c >= '０' && c <= '９') {
	        sb.setCharAt(i, (char)(c - '０' + '0'));
	      }
	    }
	    return sb.toString();
	  }

	  private static final char[] ZENKAKU_KATAKANA = { 'ァ', 'ア', 'ィ', 'イ', 'ゥ',
	      'ウ', 'ェ', 'エ', 'ォ', 'オ', 'カ', 'ガ', 'キ', 'ギ', 'ク', 'グ', 'ケ', 'ゲ',
	      'コ', 'ゴ', 'サ', 'ザ', 'シ', 'ジ', 'ス', 'ズ', 'セ', 'ゼ', 'ソ', 'ゾ', 'タ',
	      'ダ', 'チ', 'ヂ', 'ッ', 'ツ', 'ヅ', 'テ', 'デ', 'ト', 'ド', 'ナ', 'ニ', 'ヌ',
	      'ネ', 'ノ', 'ハ', 'バ', 'パ', 'ヒ', 'ビ', 'ピ', 'フ', 'ブ', 'プ', 'ヘ', 'ベ',
	      'ペ', 'ホ', 'ボ', 'ポ', 'マ', 'ミ', 'ム', 'メ', 'モ', 'ャ', 'ヤ', 'ュ', 'ユ',
	      'ョ', 'ヨ', 'ラ', 'リ', 'ル', 'レ', 'ロ', 'ヮ', 'ワ', 'ヰ', 'ヱ', 'ヲ', 'ン',
	      'ヴ', 'ヵ', 'ヶ' };

	  private static final String[] HANKAKU_KATAKANA = { "ｧ", "ｱ", "ｨ", "ｲ", "ｩ",
	      "ｳ", "ｪ", "ｴ", "ｫ", "ｵ", "ｶ", "ｶﾞ", "ｷ", "ｷﾞ", "ｸ", "ｸﾞ", "ｹ",
	      "ｹﾞ", "ｺ", "ｺﾞ", "ｻ", "ｻﾞ", "ｼ", "ｼﾞ", "ｽ", "ｽﾞ", "ｾ", "ｾﾞ", "ｿ",
	      "ｿﾞ", "ﾀ", "ﾀﾞ", "ﾁ", "ﾁﾞ", "ｯ", "ﾂ", "ﾂﾞ", "ﾃ", "ﾃﾞ", "ﾄ", "ﾄﾞ",
	      "ﾅ", "ﾆ", "ﾇ", "ﾈ", "ﾉ", "ﾊ", "ﾊﾞ", "ﾊﾟ", "ﾋ", "ﾋﾞ", "ﾋﾟ", "ﾌ",
	      "ﾌﾞ", "ﾌﾟ", "ﾍ", "ﾍﾞ", "ﾍﾟ", "ﾎ", "ﾎﾞ", "ﾎﾟ", "ﾏ", "ﾐ", "ﾑ", "ﾒ",
	      "ﾓ", "ｬ", "ﾔ", "ｭ", "ﾕ", "ｮ", "ﾖ", "ﾗ", "ﾘ", "ﾙ", "ﾚ", "ﾛ", "ﾜ",
	      "ﾜ", "ｲ", "ｴ", "ｦ", "ﾝ", "ｳﾞ", "ｶ", "ｹ" };

	  private static final char ZENKAKU_KATAKANA_FIRST_CHAR = ZENKAKU_KATAKANA[0];

	  private static final char ZENKAKU_KATAKANA_LAST_CHAR = ZENKAKU_KATAKANA[ZENKAKU_KATAKANA.length - 1];

	  /**
	   *  全角カタカナを半角カタカナに変換する
	   * @param s 変換元文字列
	   * @return 変換後文字列
	   */
	  public static String zenkakuKatakanaToHankakuKatakana(char c) {
	    if (c >= ZENKAKU_KATAKANA_FIRST_CHAR && c <= ZENKAKU_KATAKANA_LAST_CHAR) {
	      return HANKAKU_KATAKANA[c - ZENKAKU_KATAKANA_FIRST_CHAR];
	    } else {
	      return String.valueOf(c);
	    }
	  }
	  /**
	   *  全角カタカナを半角カタカナに変換する
	   * @param s 変換元文字列
	   * @return 変換後文字列
	   */
	  public static String zenkakuKatakanaToHankakuKatakana(String s) {
		if(s==null)
			return null;
	    StringBuffer sb = new StringBuffer();
	    for (int i = 0; i < s.length(); i++) {
	      char originalChar = s.charAt(i);
	      String convertedChar = zenkakuKatakanaToHankakuKatakana(originalChar);
	      sb.append(convertedChar);
	    }
	    return sb.toString();

	  }
	  private static final char[] HANKAKU_KATAKANA2 = { '｡', '｢', '｣', '､', '･',
	      'ｦ', 'ｧ', 'ｨ', 'ｩ', 'ｪ', 'ｫ', 'ｬ', 'ｭ', 'ｮ', 'ｯ', 'ｰ', 'ｱ', 'ｲ',
	      'ｳ', 'ｴ', 'ｵ', 'ｶ', 'ｷ', 'ｸ', 'ｹ', 'ｺ', 'ｻ', 'ｼ', 'ｽ', 'ｾ', 'ｿ',
	      'ﾀ', 'ﾁ', 'ﾂ', 'ﾃ', 'ﾄ', 'ﾅ', 'ﾆ', 'ﾇ', 'ﾈ', 'ﾉ', 'ﾊ', 'ﾋ', 'ﾌ',
	      'ﾍ', 'ﾎ', 'ﾏ', 'ﾐ', 'ﾑ', 'ﾒ', 'ﾓ', 'ﾔ', 'ﾕ', 'ﾖ', 'ﾗ', 'ﾘ', 'ﾙ',
	      'ﾚ', 'ﾛ', 'ﾜ', 'ﾝ', 'ﾞ', 'ﾟ' };

	  private static final char[] ZENKAKU_KATAKANA2 = { '。', '「', '」', '、', '・',
	      'ヲ', 'ァ', 'ィ', 'ゥ', 'ェ', 'ォ', 'ャ', 'ュ', 'ョ', 'ッ', 'ー', 'ア', 'イ',
	      'ウ', 'エ', 'オ', 'カ', 'キ', 'ク', 'ケ', 'コ', 'サ', 'シ', 'ス', 'セ', 'ソ',
	      'タ', 'チ', 'ツ', 'テ', 'ト', 'ナ', 'ニ', 'ヌ', 'ネ', 'ノ', 'ハ', 'ヒ', 'フ',
	      'ヘ', 'ホ', 'マ', 'ミ', 'ム', 'メ', 'モ', 'ヤ', 'ユ', 'ヨ', 'ラ', 'リ', 'ル',
	      'レ', 'ロ', 'ワ', 'ン', '゛', '゜' };

	  private static final char HANKAKU_KATAKANA_FIRST_CHAR = HANKAKU_KATAKANA2[0];

	  private static final char HANKAKU_KATAKANA_LAST_CHAR = HANKAKU_KATAKANA2[HANKAKU_KATAKANA2.length - 1];

	  /**
	   * 半角カタカナから全角カタカナへ変換します。
	   * @param c 変換前の文字
	   * @return 変換後の文字
	   */
	  public static char hankakuKatakanaToZenkakuKatakana(char c) {
	    if (c >= HANKAKU_KATAKANA_FIRST_CHAR && c <= HANKAKU_KATAKANA_LAST_CHAR) {
	      return ZENKAKU_KATAKANA2[c - HANKAKU_KATAKANA_FIRST_CHAR];
	    } else {
	      return c;
	    }
	  }
	  /**
	   * 2文字目が濁点・半濁点で、1文字目に加えることができる場合は、合成した文字を返します。
	   * 合成ができないときは、c1を返します。
	   * @param c1 変換前の1文字目
	   * @param c2 変換前の2文字目
	   * @return 変換後の文字
	   */
	  public static char mergeChar(char c1, char c2) {
	    if (c2 == 'ﾞ') {
	      if ("ｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾊﾋﾌﾍﾎ".indexOf(c1) > 0) {
	        switch (c1) {
	        case 'ｶ': return 'ガ';
	        case 'ｷ': return 'ギ';
	        case 'ｸ': return 'グ';
	        case 'ｹ': return 'ゲ';
	        case 'ｺ': return 'ゴ';
	        case 'ｻ': return 'ザ';
	        case 'ｼ': return 'ジ';
	        case 'ｽ': return 'ズ';
	        case 'ｾ': return 'ゼ';
	        case 'ｿ': return 'ゾ';
	        case 'ﾀ': return 'ダ';
	        case 'ﾁ': return 'ヂ';
	        case 'ﾂ': return 'ヅ';
	        case 'ﾃ': return 'デ';
	        case 'ﾄ': return 'ド';
	        case 'ﾊ': return 'バ';
	        case 'ﾋ': return 'ビ';
	        case 'ﾌ': return 'ブ';
	        case 'ﾍ': return 'ベ';
	        case 'ﾎ': return 'ボ';
	        }
	      }
	    } else if (c2 == 'ﾟ') {
	      if ("ﾊﾋﾌﾍﾎ".indexOf(c1) > 0) {
	        switch (c1) {
	        case 'ﾊ': return 'パ';
	        case 'ﾋ': return 'ピ';
	        case 'ﾌ': return 'プ';
	        case 'ﾍ': return 'ペ';
	        case 'ﾎ': return 'ポ';
	        }
	      }
	    }
	    return c1;
	  }

	  /**
	   * 文字列中の半角カタカナを全角カタカナに変換します。
	   * @param s 変換前文字列
	   * @return 変換後文字列
	   */
	  public static String hankakuKatakanaToZenkakuKatakana(String s) {
		if(s==null)
				return null;
	    if (s.length() == 0) {
	      return s;
	    } else if (s.length() == 1) {
	      return hankakuKatakanaToZenkakuKatakana(s.charAt(0)) + "";
	    } else {
	      StringBuffer sb = new StringBuffer(s);
	      int i = 0;
	      for (i = 0; i < sb.length() - 1; i++) {
	        char originalChar1 = sb.charAt(i);
	        char originalChar2 = sb.charAt(i + 1);
	        char margedChar = mergeChar(originalChar1, originalChar2);
	        if (margedChar != originalChar1) {
	          sb.setCharAt(i, margedChar);
	          sb.deleteCharAt(i + 1);
	        } else {
	          char convertedChar = hankakuKatakanaToZenkakuKatakana(originalChar1);
	          if (convertedChar != originalChar1) {
	            sb.setCharAt(i, convertedChar);
	          }
	        }
	      }
	      if (i < sb.length()) {
	        char originalChar1 = sb.charAt(i);
	        char convertedChar = hankakuKatakanaToZenkakuKatakana(originalChar1);
	        if (convertedChar != originalChar1) {
	          sb.setCharAt(i, convertedChar);
	        }
	      }
	      return sb.toString();
	       }

	  }

		/**
		 * 文件路径合并
		 * @param filePath1
		 * @param filePath2
		 * @return
		 */
		public static String linkFilePath(String filePath1, String filePath2)
		{
			String fileSeparator = System.getProperty("file.separator");
			String repFileSeparator = fileSeparator;
			if("\\".equals(fileSeparator))
			{
				repFileSeparator = repFileSeparator + "\\";
			}
			String newFilePath1 = filePath1.replaceAll("[\\\\/]{1}", repFileSeparator).replaceAll("[\\\\/]{1}$", "");
			String newFilePath2 = filePath2.replaceAll("[\\\\/]{1}", repFileSeparator).replaceAll("^[\\\\/]{1}", "");
			return newFilePath1 + fileSeparator + newFilePath2;
		}

		/**
		 * 取得文件路径
		 * @param inputFile
		 * @return
		 */
		public static String getFilePath(String inputFile)
		{
			String result = inputFile.replaceAll("[\\\\/][^\\\\/]+$", "");
			return result;
		}

		/**
		 * 取得文件名
		 * @param inputFile
		 * @return
		 */
		public static String getFileName(String inputFile)
		{
			String result = inputFile.replaceAll(".*[\\\\/]", "");
			return result;
		}
}
